home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 363_01 / insttabl.c < prev    next >
C/C++ Source or Header  |  1991-12-15  |  36KB  |  1,080 lines
  1. /***********************************************************************
  2.  *
  3.  *      INSTTABLE.C
  4.  *      Instruction Table for 68020 Assembler
  5.  *
  6.  * Description: This file contains two kinds of data structure declarations: 
  7.  *      "variant lists" and the instruction table. First in the file are 
  8.  *      "variant lists," one for each different instruction. Then comes the 
  9.  *      instruction table, which contains the mnemonics of the various 
  10.  *      instructions, a pointer to the variant list for each instruction, and
  11.  *      other data. Finally, the variable tableSize is initialized to contain 
  12.  *      the number of instructions in the instruction table.
  13.  *
  14.  *      Author: Paul McKee
  15.  *      ECE492    North Carolina State University, 12/13/86
  16.  *
  17.  *      Modified A.E. Romer, Version 1.0     16 March 1991
  18.  *          5 October 1991 - TRAP instruction got lost somehow, restored
  19.  ************************************************************************/
  20.  
  21. /*********************************************************************
  22.  
  23.           HOW THE INSTRUCTION TABLE AND VARIANT LISTS ARE USED
  24.  
  25.      The procedure which instLookup() and assemble() use to look up
  26. and verify an instruction (or directive) is as follows. Once the
  27. mnemonic of the instruction has been parsed and stripped of its size
  28. code and trailing spaces, the instLookup() does a binary search on the
  29. instruction table to determine if the mnemonic is present. If it is
  30. not found, then the INV_OPCODE error results. If the mnemonic is
  31. found, then assemble() examines the field parseFlag for that entry.
  32. This flag is TRUE if the mnemonic represents a normal instruction that
  33. can be parsed by assemble(); it is FALSE if the instruction's operands
  34. have an unusual format (as is the case for MOVEM and DC).
  35.  
  36.       If the parseFlag is TRUE, then assemble will parse the
  37. instruction's operands, check them for validity, and then pass the
  38. data to the proper routine which will build the instruction. To do
  39. this it uses the pointer in the instruction table to the instruction's
  40. "variant list" and scans through the list until it finds an particular
  41. "variant" of the instruction which matches the addressing mode(s)
  42. specified.  If it finds such a variant, it checks the instruction's
  43. size code and passes the instruction mask for the appropriate size
  44. (there are three masks for each variant) to the building routine
  45. through a pointer in the variant list for that variant.
  46.  
  47. *********************************************************************/
  48.  
  49.  
  50. #include <stdio.h>
  51. #include "asm.h"
  52.  
  53. /* Define size code masks for instructions that allow more than one size */
  54.  
  55. #define BW  (BYTE | WORD)
  56. #define WL  (WORD | LONG)
  57. #define BWL (BYTE | WORD | LONG)
  58. #define BL  (BYTE | LONG)
  59.  
  60.  
  61. /* Define the "variant lists" for each different instruction */
  62.  
  63. /* NOTE: in the following variant lists it is essential that variants that do
  64.  * not require destination (for instance 'asl' MemAlt variant) precede variants
  65.  * that do. The reason is that 'assemble' parses variants in the order of this
  66.  * listing, so if the variant in the code parsed were one that does not require
  67.  * destination, 'assemble' would try to parse the destination if the variants
  68.  * were listed in the wrong order, and fail.
  69.  */
  70.  
  71. variant abcdva[] =
  72.     {
  73.         { DnDirect, DnDirect, BYTE, twoReg, 0xC100, 0xC100, 0 },
  74.         { AnIndPre, AnIndPre, BYTE, twoReg, 0xC108, 0xC108, 0 }
  75.     };
  76.  
  77. variant addva[] =
  78.     {
  79.         { Immediate, DataAlt,  BWL, immedInst, 0x0600, 0x0640, 0x0680 },
  80.         { Immediate, AnDirect, WL,  quickMath, 0,      0x5040, 0x5080 },
  81.         { All,       DnDirect, BWL, arithReg,  0xD000, 0xD040, 0xD080 },
  82.         { DnDirect,  MemAlt,   BWL, arithAddr, 0xD100, 0xD140, 0xD180 },
  83.         { All,       AnDirect, WL,  arithReg,  0,      0xD0C0, 0xD1C0 },
  84.     };
  85.  
  86. variant addava[] =
  87.     {
  88.         { All, AnDirect, WL, arithReg, 0, 0xD0C0, 0xD1C0 },
  89.     };
  90.  
  91. variant addiva[] =
  92.     {
  93.         { Immediate, DataAlt, BWL, immedInst, 0x0600, 0x0640, 0x0680 }
  94.     };
  95.  
  96. variant addqva[] =
  97.     {
  98.         { Immediate, DataAlt, BWL, quickMath, 0x5000, 0x5040, 0x5080 },
  99.         { Immediate, AnDirect, WL, quickMath, 0,      0x5040, 0x5080 }
  100.     };
  101.  
  102. variant addxva[] =
  103.     {
  104.         { DnDirect, DnDirect, BWL, twoReg, 0xD100, 0xD140, 0xD180 },
  105.         { AnIndPre, AnIndPre, BWL, twoReg, 0xD108, 0xD148, 0xD188 }
  106.     };
  107.  
  108. variant andva[] =
  109.     {
  110.         { Data,      DnDirect, BWL, arithReg,  0xC000, 0xC040, 0xC080 },
  111.         { DnDirect,  MemAlt,   BWL, arithAddr, 0xC100, 0xC140, 0xC180 },
  112.         { Immediate, DataAlt,  BWL, immedInst, 0x0200, 0x0240, 0x0280 }
  113.     };
  114.  
  115. variant andiva[] =
  116.     {
  117.         { Immediate, DataAlt,   BWL,  immedInst,  0x0200, 0x0240, 0x0280 },
  118.         { Immediate, CCRDirect, BYTE, immedToCCR, 0x023C, 0x023C, 0 },
  119.         { Immediate, SRDirect,  WORD, immedWord,  0,      0x027C, 0 }
  120.     };
  121.  
  122. variant aslva[] =
  123.     {
  124.         { MemAlt,    0,        WORD, oneOp,    0,      0xE1C0, 0 },
  125.         { DnDirect,  DnDirect, BWL,  shiftReg, 0xE120, 0xE160, 0xE1A0 },
  126.         { Immediate, DnDirect, BWL,  shiftReg, 0xE100, 0xE140, 0xE180 }
  127.     };
  128.  
  129. variant asrva[] =
  130.     {
  131.         { MemAlt,    0,        WORD, oneOp,    0,      0xE0C0, 0 },
  132.         { DnDirect,  DnDirect, BWL,  shiftReg, 0xE020, 0xE060, 0xE0A0 },
  133.         { Immediate, DnDirect, BWL,  shiftReg, 0xE000, 0xE040, 0xE080 }
  134.     };
  135.  
  136. variant bccva[] =
  137.     {
  138.         { Absolute, 0, SHORT | LONG, branch, 0x6400, 0x6400, 0x6400 }
  139.     };
  140.  
  141. variant bchgva[] =
  142.     {
  143.         { DnDirect,  MemAlt,   BYTE, arithAddr, 0x0140, 0x0140, 0 },
  144.         { DnDirect,  DnDirect, LONG, arithAddr, 0,      0x0140, 0x0140 },
  145.         { Immediate, MemAlt,   BYTE, staticBit, 0x0840, 0x0840, 0 },
  146.         { Immediate, DnDirect, LONG, staticBit, 0,      0x0840, 0x0840 }
  147.     };
  148.  
  149. variant bclrva[] =
  150.     {
  151.         { DnDirect, MemAlt, BYTE, arithAddr, 0x0180, 0x0180, 0 },
  152.         { DnDirect, DnDirect, LONG, arithAddr, 0, 0x0180, 0x0180 },
  153.         { Immediate, MemAlt, BYTE, staticBit, 0x0880, 0x0880, 0 },
  154.         { Immediate, DnDirect, LONG, staticBit, 0, 0x0880, 0x0880 }
  155.     };
  156.  
  157. variant bcsva[] =
  158.     {
  159.         { Absolute, 0, SHORT | LONG, branch, 0x6500, 0x6500, 0x6500 }
  160.     };
  161.  
  162. variant beqva[] =
  163.     {
  164.         { Absolute, 0, SHORT | LONG, branch, 0x6700, 0x6700, 0x6700 }
  165.     };
  166.  
  167. variant bfchgva[] =
  168.     {
  169.         { DnDirect | CtrAlt, 0, 0, NULL, 0x0, 0xEAC0, 0x0 }
  170.     };
  171.  
  172. variant bfclrva[] =
  173.     {
  174.         { DnDirect | CtrAlt, 0, 0, NULL, 0x0, 0xECC0, 0x0 }
  175.     };
  176.  
  177. variant bfextsva[] =
  178.     {
  179.         { DnDirect | Control, DnDirect, 0, NULL, 0x0, 0xEBC0, 0x0 }
  180.     };
  181.  
  182. variant bfextuva[] =
  183.     {
  184.         { DnDirect | Control, DnDirect, 0, NULL, 0x0, 0xE9C0, 0x0 }
  185.     };
  186.  
  187. variant bfffova[] =
  188.     {
  189.         { DnDirect | Control, DnDirect, 0, NULL, 0x0, 0xEDC0, 0x0 }
  190.     };
  191.  
  192. variant bfinsva[] =
  193.     {
  194.         { DnDirect, DnDirect | Control, 0, NULL, 0x0, 0xEFC0, 0x0 }
  195.     };
  196.  
  197. variant bfsetva[] =
  198.     {
  199.         { DnDirect | CtrAlt, 0, 0, NULL, 0x0, 0xEEC0, 0x0 }
  200.     };
  201.  
  202. variant bftstva[] =
  203.     {
  204.         { DnDirect | CtrAlt, 0, 0, NULL, 0x0, 0xE8C0, 0x0 }
  205.     };
  206.  
  207. variant bgeva[] =
  208.     {
  209.         { Absolute, 0, SHORT | LONG, branch, 0x6C00, 0x6C00, 0x6C00 }
  210.     };
  211.  
  212. variant bgtva[] =
  213.     {
  214.         { Absolute, 0, SHORT | LONG, branch, 0x6E00, 0x6E00, 0x6E00 }
  215.     };
  216.  
  217. variant bhiva[] =
  218.     {
  219.         { Absolute, 0, SHORT | LONG, branch, 0x6200, 0x6200, 0x6200 }
  220.     };
  221.  
  222. variant bhsva[] =
  223.     {
  224.         { Absolute, 0, SHORT | LONG, branch, 0x6400, 0x6400, 0x6400 }
  225.     };
  226.  
  227. variant bleva[] =
  228.     {
  229.         { Absolute, 0, SHORT | LONG, branch, 0x6f00, 0x6F00, 0x6F00 }
  230.     };
  231.  
  232. variant blova[] =
  233.     {
  234.         { Absolute, 0, SHORT | LONG, branch, 0x6500, 0x6500, 0x6500 }
  235.     };
  236.  
  237. variant blsva[] =
  238.     {
  239.         { Absolute, 0, SHORT | LONG, branch, 0x6300, 0x6300, 0x6300 }
  240.     };
  241.  
  242. variant bltva[] =
  243.     {
  244.         { Absolute, 0, SHORT | LONG, branch, 0x6d00, 0x6D00, 0x6D00 }
  245.     };
  246.  
  247. variant bmiva[] =
  248.     {
  249.         { Absolute, 0, SHORT | LONG, branch, 0x6b00, 0